home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / src-glu / project.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-29  |  10.2 KB  |  390 lines
  1. /* $Id: project.c,v 1.2 1997/01/29 19:05:29 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.2
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: project.c,v $
  26.  * Revision 1.2  1997/01/29 19:05:29  brianp
  27.  * faster invert_matrix() function from Stephane Rehel
  28.  *
  29.  * Revision 1.1  1996/09/27 01:19:39  brianp
  30.  * Initial revision
  31.  *
  32.  */
  33.  
  34.  
  35. #include <stdio.h>
  36. #include <string.h>
  37. #include <math.h>
  38. #include "gluP.h"
  39.  
  40.  
  41. /*
  42.  * This code was contributed by Marc Buffat (buffat@mecaflu.ec-lyon.fr).
  43.  * Thanks Marc!!!
  44.  */
  45.  
  46.  
  47.  
  48. /* implementation de gluProject et gluUnproject */
  49. /* M. Buffat 17/2/95 */
  50.  
  51.  
  52.  
  53. /*
  54.  * Transform a point (column vector) by a 4x4 matrix.  I.e.  out = m * in
  55.  * Input:  m - the 4x4 matrix
  56.  *         in - the 4x1 vector
  57.  * Output:  out - the resulting 4x1 vector.
  58.  */
  59. static void transform_point( GLdouble out[4], const GLdouble m[16],
  60.                  const GLdouble in[4] )
  61. {
  62. #define M(row,col)  m[col*4+row]
  63.    out[0] = M(0,0) * in[0] + M(0,1) * in[1] + M(0,2) * in[2] + M(0,3) * in[3];
  64.    out[1] = M(1,0) * in[0] + M(1,1) * in[1] + M(1,2) * in[2] + M(1,3) * in[3];
  65.    out[2] = M(2,0) * in[0] + M(2,1) * in[1] + M(2,2) * in[2] + M(2,3) * in[3];
  66.    out[3] = M(3,0) * in[0] + M(3,1) * in[1] + M(3,2) * in[2] + M(3,3) * in[3];
  67. #undef M
  68. }
  69.  
  70.  
  71.  
  72.  
  73. /*
  74.  * Perform a 4x4 matrix multiplication  (product = a x b).
  75.  * Input:  a, b - matrices to multiply
  76.  * Output:  product - product of a and b
  77.  */
  78. static void matmul( GLdouble *product, const GLdouble *a, const GLdouble *b )
  79. {
  80.    /* This matmul was contributed by Thomas Malik */
  81.    GLdouble temp[16];
  82.    GLint i;
  83.  
  84. #define A(row,col)  a[(col<<2)+row]
  85. #define B(row,col)  b[(col<<2)+row]
  86. #define T(row,col)  temp[(col<<2)+row]
  87.  
  88.    /* i-te Zeile */
  89.    for (i = 0; i < 4; i++)
  90.      {
  91.     T(i, 0) = A(i, 0) * B(0, 0) + A(i, 1) * B(1, 0) + A(i, 2) * B(2, 0) + A(i, 3) * B(3, 0);
  92.     T(i, 1) = A(i, 0) * B(0, 1) + A(i, 1) * B(1, 1) + A(i, 2) * B(2, 1) + A(i, 3) * B(3, 1);
  93.     T(i, 2) = A(i, 0) * B(0, 2) + A(i, 1) * B(1, 2) + A(i, 2) * B(2, 2) + A(i, 3) * B(3, 2);
  94.     T(i, 3) = A(i, 0) * B(0, 3) + A(i, 1) * B(1, 3) + A(i, 2) * B(2, 3) + A(i, 3) * B(3, 3);
  95.      }
  96.  
  97. #undef A
  98. #undef B
  99. #undef T
  100.    MEMCPY( product, temp, 16*sizeof(GLdouble) );
  101. }
  102.  
  103.  
  104. static GLdouble Identity[16] = {
  105.    1.0, 0.0, 0.0, 0.0,
  106.    0.0, 1.0, 0.0, 0.0,
  107.    0.0, 0.0, 1.0, 0.0,
  108.    0.0, 0.0, 0.0, 1.0
  109. };
  110.  
  111.  
  112.  
  113. /*
  114.  * Compute the inverse of a 4x4 matrix.  Contributed by scotter@lafn.org
  115.  */
  116. static void invert_matrix_general( const GLdouble *m, GLdouble *out )
  117. {
  118.  
  119. /* NB. OpenGL Matrices are COLUMN major. */
  120. #define MAT(m,r,c) (m)[(c)*4+(r)]
  121.  
  122. /* Here's some shorthand converting standard (row,column) to index. */
  123. #define m11 MAT(m,0,0)
  124. #define m12 MAT(m,0,1)
  125. #define m13 MAT(m,0,2)
  126. #define m14 MAT(m,0,3)
  127. #define m21 MAT(m,1,0)
  128. #define m22 MAT(m,1,1)
  129. #define m23 MAT(m,1,2)
  130. #define m24 MAT(m,1,3)
  131. #define m31 MAT(m,2,0)
  132. #define m32 MAT(m,2,1)
  133. #define m33 MAT(m,2,2)
  134. #define m34 MAT(m,2,3)
  135. #define m41 MAT(m,3,0)
  136. #define m42 MAT(m,3,1)
  137. #define m43 MAT(m,3,2)
  138. #define m44 MAT(m,3,3)
  139.  
  140.    GLdouble det;
  141.    GLdouble d12, d13, d23, d24, d34, d41;
  142.    GLdouble tmp[16]; /* Allow out == in. */
  143.  
  144.    /* Inverse = adjoint / det. (See linear algebra texts.)*/
  145.  
  146.    /* pre-compute 2x2 dets for last two rows when computing */
  147.    /* cofactors of first two rows. */
  148.    d12 = (m31*m42-m41*m32);
  149.    d13 = (m31*m43-m41*m33);
  150.    d23 = (m32*m43-m42*m33);
  151.    d24 = (m32*m44-m42*m34);
  152.    d34 = (m33*m44-m43*m34);
  153.    d41 = (m34*m41-m44*m31);
  154.  
  155.    tmp[0] =  (m22 * d34 - m23 * d24 + m24 * d23);
  156.    tmp[1] = -(m21 * d34 + m23 * d41 + m24 * d13);
  157.    tmp[2] =  (m21 * d24 + m22 * d41 + m24 * d12);
  158.    tmp[3] = -(m21 * d23 - m22 * d13 + m23 * d12);
  159.  
  160.    /* Compute determinant as early as possible using these cofactors. */
  161.    det = m11 * tmp[0] + m12 * tmp[1] + m13 * tmp[2] + m14 * tmp[3];
  162.  
  163.    /* Run singularity test. */
  164.    if (det == 0.0) {
  165.       /* printf("invert_matrix: Warning: Singular matrix.\n"); */
  166.       MEMCPY( out, Identity, 16*sizeof(GLdouble) );
  167.    }
  168.    else {
  169.       GLdouble invDet = 1.0 / det;
  170.       /* Compute rest of inverse. */
  171.       tmp[0] *= invDet;
  172.       tmp[1] *= invDet;
  173.       tmp[2] *= invDet;
  174.       tmp[3] *= invDet;
  175.  
  176.       tmp[4] = -(m12 * d34 - m13 * d24 + m14 * d23) * invDet;
  177.       tmp[5] =  (m11 * d34 + m13 * d41 + m14 * d13) * invDet;
  178.       tmp[6] = -(m11 * d24 + m12 * d41 + m14 * d12) * invDet;
  179.       tmp[7] =  (m11 * d23 - m12 * d13 + m13 * d12) * invDet;
  180.  
  181.       /* Pre-compute 2x2 dets for first two rows when computing */
  182.       /* cofactors of last two rows. */
  183.       d12 = m11*m22-m21*m12;
  184.       d13 = m11*m23-m21*m13;
  185.       d23 = m12*m23-m22*m13;
  186.       d24 = m12*m24-m22*m14;
  187.       d34 = m13*m24-m23*m14;
  188.       d41 = m14*m21-m24*m11;
  189.  
  190.       tmp[8] =  (m42 * d34 - m43 * d24 + m44 * d23) * invDet;
  191.       tmp[9] = -(m41 * d34 + m43 * d41 + m44 * d13) * invDet;
  192.       tmp[10] =  (m41 * d24 + m42 * d41 + m44 * d12) * invDet;
  193.       tmp[11] = -(m41 * d23 - m42 * d13 + m43 * d12) * invDet;
  194.       tmp[12] = -(m32 * d34 - m33 * d24 + m34 * d23) * invDet;
  195.       tmp[13] =  (m31 * d34 + m33 * d41 + m34 * d13) * invDet;
  196.       tmp[14] = -(m31 * d24 + m32 * d41 + m34 * d12) * invDet;
  197.       tmp[15] =  (m31 * d23 - m32 * d13 + m33 * d12) * invDet;
  198.  
  199.       MEMCPY(out, tmp, 16*sizeof(GLdouble));
  200.    }
  201.  
  202. #undef m11
  203. #undef m12
  204. #undef m13
  205. #undef m14
  206. #undef m21
  207. #undef m22
  208. #undef m23
  209. #undef m24
  210. #undef m31
  211. #undef m32
  212. #undef m33
  213. #undef m34
  214. #undef m41
  215. #undef m42
  216. #undef m43
  217. #undef m44
  218. #undef MAT
  219. }
  220.  
  221.  
  222. /*
  223.  * Invert matrix m.  This algorithm contributed by Stephane Rehel
  224.  * <rehel@worldnet.fr>
  225.  */
  226. static void invert_matrix( const GLdouble *m, GLdouble *out )
  227. {
  228. /* NB. OpenGL Matrices are COLUMN major. */
  229. #define MAT(m,r,c) (m)[(c)*4+(r)]
  230.  
  231. /* Here's some shorthand converting standard (row,column) to index. */
  232. #define m11 MAT(m,0,0)
  233. #define m12 MAT(m,0,1)
  234. #define m13 MAT(m,0,2)
  235. #define m14 MAT(m,0,3)
  236. #define m21 MAT(m,1,0)
  237. #define m22 MAT(m,1,1)
  238. #define m23 MAT(m,1,2)
  239. #define m24 MAT(m,1,3)
  240. #define m31 MAT(m,2,0)
  241. #define m32 MAT(m,2,1)
  242. #define m33 MAT(m,2,2)
  243. #define m34 MAT(m,2,3)
  244. #define m41 MAT(m,3,0)
  245. #define m42 MAT(m,3,1)
  246. #define m43 MAT(m,3,2)
  247. #define m44 MAT(m,3,3)
  248.  
  249.    register GLdouble det;
  250.    GLdouble tmp[16]; /* Allow out == in. */
  251.  
  252.    if( m41 != 0. || m42 != 0. || m43 != 0. || m44 != 1. ) {
  253.       invert_matrix_general(m, out);
  254.       return;
  255.    }
  256.  
  257.    /* Inverse = adjoint / det. (See linear algebra texts.)*/
  258.  
  259.    tmp[0]= m22 * m33 - m23 * m32;
  260.    tmp[1]= m23 * m31 - m21 * m33;
  261.    tmp[2]= m21 * m32 - m22 * m31;
  262.  
  263.    /* Compute determinant as early as possible using these cofactors. */
  264.    det= m11 * tmp[0] + m12 * tmp[1] + m13 * tmp[2];
  265.  
  266.    /* Run singularity test. */
  267.    if (det == 0.0) {
  268.       /* printf("invert_matrix: Warning: Singular matrix.\n"); */
  269.       MEMCPY( out, Identity, 16*sizeof(GLdouble) );
  270.    }
  271.    else {
  272.       GLdouble d12, d13, d23, d24, d34, d41;
  273.       register GLdouble im11, im12, im13, im14;
  274.  
  275.       det= 1. / det;
  276.  
  277.       /* Compute rest of inverse. */
  278.       tmp[0] *= det;
  279.       tmp[1] *= det;
  280.       tmp[2] *= det;
  281.       tmp[3]  = 0.;
  282.  
  283.       im11= m11 * det;
  284.       im12= m12 * det;
  285.       im13= m13 * det;
  286.       im14= m14 * det;
  287.       tmp[4] = im13 * m32 - im12 * m33;
  288.       tmp[5] = im11 * m33 - im13 * m31;
  289.       tmp[6] = im12 * m31 - im11 * m32;
  290.       tmp[7] = 0.;
  291.  
  292.       /* Pre-compute 2x2 dets for first two rows when computing */
  293.       /* cofactors of last two rows. */
  294.       d12 = im11*m22 - m21*im12;
  295.       d13 = im11*m23 - m21*im13;
  296.       d23 = im12*m23 - m22*im13;
  297.       d24 = im12*m24 - m22*im14;
  298.       d34 = im13*m24 - m23*im14;
  299.       d41 = im14*m21 - m24*im11;
  300.  
  301.       tmp[8] =  d23;
  302.       tmp[9] = -d13;
  303.       tmp[10] = d12;
  304.       tmp[11] = 0.;
  305.  
  306.       tmp[12] = -(m32 * d34 - m33 * d24 + m34 * d23);
  307.       tmp[13] =  (m31 * d34 + m33 * d41 + m34 * d13);
  308.       tmp[14] = -(m31 * d24 + m32 * d41 + m34 * d12);
  309.       tmp[15] =  1.;
  310.  
  311.       MEMCPY(out, tmp, 16*sizeof(GLdouble));
  312.   }
  313.  
  314. #undef m11
  315. #undef m12
  316. #undef m13
  317. #undef m14
  318. #undef m21
  319. #undef m22
  320. #undef m23
  321. #undef m24
  322. #undef m31
  323. #undef m32
  324. #undef m33
  325. #undef m34
  326. #undef m41
  327. #undef m42
  328. #undef m43
  329. #undef m44
  330. #undef MAT
  331. }
  332.  
  333.  
  334.  
  335. /* projection du point (objx,objy,obz) sur l'ecran (winx,winy,winz) */
  336. GLint gluProject(GLdouble objx,GLdouble objy,GLdouble objz,
  337.                  const GLdouble model[16],const GLdouble proj[16],
  338.                  const GLint viewport[4],
  339.                  GLdouble *winx,GLdouble *winy,GLdouble *winz)
  340. {
  341.     /* matrice de transformation */
  342.     GLdouble in[4],out[4];
  343.  
  344.     /* initilise la matrice et le vecteur a transformer */
  345.     in[0]=objx; in[1]=objy; in[2]=objz; in[3]=1.0;
  346.     transform_point(out,model,in);
  347.     transform_point(in,proj,out);
  348.  
  349.     /* d'ou le resultat normalise entre -1 et 1*/
  350.     in[0]/=in[3];in[1]/=in[3];in[2]/=in[3];
  351.  
  352.     /* en coordonnees ecran */
  353.     *winx = viewport[0]+(1+in[0])*viewport[2]/2;
  354.     *winy = viewport[1]+(1+in[1])*viewport[3]/2;
  355.     /* entre 0 et 1 suivant z */
  356.     *winz = (1+in[2])/2;
  357.     return GL_TRUE;
  358. }
  359.  
  360.  
  361.  
  362. /* transformation du point ecran (winx,winy,winz) en point objet */
  363. GLint gluUnProject(GLdouble winx,GLdouble winy,GLdouble winz,
  364.                    const GLdouble model[16],const GLdouble proj[16],
  365.                    const GLint viewport[4],
  366.                    GLdouble *objx,GLdouble *objy,GLdouble *objz)
  367. {
  368.     /* matrice de transformation */
  369.     GLdouble m[16], A[16];
  370.     GLdouble in[4],out[4];
  371.  
  372.     /* transformation coordonnees normalisees entre -1 et 1 */
  373.     in[0]=(winx-viewport[0])*2/viewport[2] - 1.0;
  374.     in[1]=(winy-viewport[1])*2/viewport[3] - 1.0;
  375.     in[2]=2*winz - 1.0;
  376.     in[3]=1.0;
  377.  
  378.     /* calcul transformation inverse */
  379.     matmul(A,proj,model);
  380.     invert_matrix(A,m);
  381.  
  382.     /* d'ou les coordonnees objets */
  383.     transform_point(out,m,in);
  384.     *objx=out[0]/out[3];
  385.     *objy=out[1]/out[3];
  386.     *objz=out[2]/out[3];
  387.     return GL_TRUE;
  388. }
  389.  
  390.